Exploiting novelty
Grapheme-to-phoneme conversion (GTPC) has been achieved in most European languagesby dictionary look-up or using rules. The application of these methods, however, in the reverse pro-cess, (i.e., in phoneme-to-grapheme conversion [PTGC]) creates serious problems, especially in inflectionally rich languages. In this paper the PTGC problem is approached from a completely different point of view. Instead of rules or a dictionary, the statistics of language connecting pro-nunciation to spelling are exploited. The novelty lies in modeling the natural language intraword features using the theory of hidden Markov models (HMM) and performing the conversion using the Viterbi algorithm. The PTGC system has been established and tested on various multilingual corpora. Initially, the first-order HMM and the common Viterbi algorithm were used to obtain a single transcription for each word. Afterwards, the second-order HMM and the N-best algorithm adapted to PTGC were implemented to provide one or more transcriptions for each word input (homophones). This system gave an average score of more than 99 % correctly transcribed words (overall success in the first four candidates)for most of the seven languages it was tested on (Dutch, English, French, German, Greek, Italian, and Spanish). The system can be adapted to almost any language with little effort and can be implemented in hardware to serve in real-time speech recognition systems. 1.
Loop Formulas for Description Logic Programs

Clustering with feature order preferences.

Loop formulas for description logic programs.

Maximum margin transfer learning.

Maximum margin transfer learning.

Topic Modeling for Sequences of Temporal Activities.

A Decomposition%2DBased Approach to Optimizing Conjunctive Query Answering in OWL DL.

A Default Approach to Semantics of Logic Programs with Constraint Atoms.
Abstract. We define the semantics of logic programs with (abstract) constraint atoms in a way closely tied to default logic. Like default logic, formulas in rules are evaluated using the classical entailment relation, so a constraint atom can be represented by an equivalent propositional formula. Therefore, answer sets are defined in a way closely related to default extensions. The semantics defined this way enjoys two properties generally considered desirable for answer set programming − minimality and derivability. The derivability property is very important because it guarantees free of self-supporting loops in answer sets. We show that when restricted to basic logic programs, this semantics agrees with the conditional-satisfaction based semantics. Furthermore, answer sets by the minimal-model based semantics can be recast in our approach. Consequently, the default approach gives a unifying account of the major existing semantics for logic programs with constraint atoms. This also makes it possible to characterize, in terms of the minimality and derivability properties, the precise relationship between them and contrast with others. 1
Regularized Local Reconstruction for Clustering.

Characterizations of Stable Model Semantics for Logic Programs with Arbitrary Constraint Atoms
This paper studies the stable model semantics of logic programs with (abstract) constraint atoms and their properties. We introduce a succinct abstract representation of these constraint atoms in which a constraint atom is represented compactly. We show two applications. First, under this representation of constraint atoms, we generalize the Gelfond–Lifschitz transformation and apply it to define stable models (also called answer sets) for logic programs with arbitrary constraint atoms. The resulting semantics turns out to coincide with the one defined by Son et al. (2007), which is based on a fixpoint approach. One advantage of our approach is that it can be applied, in a natural way, to define stable models for disjunctive logic programs with constraint atoms, which may appear in the disjunctive head as well as in the body of a rule. As a result, our approach to the stable model semantics for logic programs with constraint atoms generalizes a number of previous approaches. Second, we show that our abstract representation of constraint atoms provides a means to characterize dependencies of atoms in a program with constraint atoms, so that some standard characterizations and properties relying on these dependencies in the past for logic programs with ordinary atoms can be extended to logic programs with constraint atoms.
Termination Prediction for General Logic Programs
We present an approximation framework for attacking the undecidable termination problem of logic programs, as an alternative to current termination/non-termination proof approaches. We introduce an idea of termination prediction, which predicts termination of a logic program in case that neither a termination nor a nontermination proof is applicable. We establish a necessary and sufficient characterization of infinite (generalized) SLDNF-derivations with arbitrary (concrete or moded) queries, and develop an algorithm that predicts termination of general logic programs with arbitrary queries. We have implemented a termination prediction system and obtained quite satisfactory experimental results. Our prediction is 100 % correct for all benchmark programs of the Termination Competition 2007, of which eighteen programs cannot be proved by the existing state-of-the-art analyzers like AP roV E07, NT I, P olytool and T ALP.
Characterizations of stable model semantics for logic programs with arbitrary constraint atoms.
This paper studies the stable model semantics of logic programs with (abstract) constraint atoms and their properties. We introduce a succinct abstract representation of these constraint atoms in which a constraint atom is represented compactly. We show two applications. First, under this representation of constraint atoms, we generalize the Gelfond–Lifschitz transformation and apply it to define stable models (also called answer sets) for logic programs with arbitrary constraint atoms. The resulting semantics turns out to coincide with the one defined by Son et al. (2007), which is based on a fixpoint approach. One advantage of our approach is that it can be applied, in a natural way, to define stable models for disjunctive logic programs with constraint atoms, which may appear in the disjunctive head as well as in the body of a rule. As a result, our approach to the stable model semantics for logic programs with constraint atoms generalizes a number of previous approaches. Second, we show that our abstract representation of constraint atoms provides a means to characterize dependencies of atoms in a program with constraint atoms, so that some standard characterizations and properties relying on these dependencies in the past for logic programs with ordinary atoms can be extended to logic programs with constraint atoms.
Termination prediction for general logic programs.
We present an approximation framework for attacking the undecidable termination problem of logic programs, as an alternative to current termination/non-termination proof approaches. We introduce an idea of termination prediction, which predicts termination of a logic program in case that neither a termination nor a nontermination proof is applicable. We establish a necessary and sufficient characterization of infinite (generalized) SLDNF-derivations with arbitrary (concrete or moded) queries, and develop an algorithm that predicts termination of general logic programs with arbitrary queries. We have implemented a termination prediction system and obtained quite satisfactory experimental results. Our prediction is 100 % correct for all benchmark programs of the Termination Competition 2007, of which eighteen programs cannot be proved by the existing state-of-the-art analyzers like AP roV E07, NT I, P olytool and T ALP.
Clustering Via Local Regression.
Abstract. This paper deals with the local learning approach for clustering, which is based on the idea that in a good clustering, the cluster labelofeachdatapointcanbewellpredictedbasedonitsneighborsand their cluster labels. We propose a novel local learning based clustering algorithm using kernel regression as the local label predictor. Although sum of absolute error is used instead of sum of squared error, we still obtain an algorithm that clusters the data by exploiting the eigen-structure of a sparse matrix. Experimental results on many data sets demonstrate the effectiveness and potential of the proposed method.
Collective Latent Dirichlet Allocation.
In this paper, we propose a new variant of Latent Dirichlet Allocation(LDA): Collective LDA (C-LDA), for multiple corpora modeling. C-LDA combines multiple corpora during learning such that it can transfer knowledge from one corpus to another; meanwhile it keeps a discriminative node which represents the corpus ID to constrain the learned topics in each corpus. Compared with LDA locally applied to the target corpus, C-LDA results in refined topicword distribution, while compared with applying LDA globally and straightforwardly to the combined corpus, C-LDA keeps each topic only for one corpus. We demonstrate that C-LDA has improved performance with these advantages by experiments on several benchmark document data sets. 1.
R%2DMap Mapping Categorical Data for Clustering and Visualization Based on Reference Sets.

Clustering with Feature Order Preferences.

Lexicographical Inference over Inconsistent DL%2DBased Ontologies.

Computing minimum cost diagnoses to repair populated DL%2Dbased ontologies.
Ontology population is prone to cause inconsistency because the populating process is imprecise or the populated data may conflict with the original data. By assuming that the intensional part of the populated DL-based ontology is fixed and each removable ABox assertion is given a removal cost, we repair the ontology by deleting a subset of removable ABox assertions in which the sum of removal costs is minimum. We call such subset a minimum cost diagnosis. We show that, unless P=NP, the problem of finding a minimum cost diagnosis for a DL-Lite ontology is insolvable in PTIME w.r.t. data complexity. In spite of that, we present a feasible computational method for more general (i.e. SHIQ) ontologies. It transforms a SHIQ ontology to a set of disjoint propositional programs, thus reducing the original problem into a set of independent subproblems. Each such subproblem computes an optimal model and is solvable in logarithmic calls to a SAT solver. Experimental results show that the method can handle moderately complex ontologies with over thousands of ABox assertions, where all ABox assertions can be assumed removable.
Reasoning with recursive loops under the PLP framework.

Basic research in computer science and software engineering at SKLCS.

Linear tabling strategies and optimizations.

A Generalized Gelfond%2DLifschitz Transformation for Logic Programs with Abstract Constraints.
We present a generalized Gelfond-Lifschitz transformation in order to define stable models for a logic program with arbitrary abstract constraints on sets (c-atoms). The generalization is based on a formal semantics and a novel abstract representation of c-atoms, as opposed to the commonly used power set form representation. In many cases, the abstract representation of a c-atom results in a substantial reduction of size from its power set form representation. We show that any c-atom A =(Ad,Ac) in the body of a clause can be characterized using its satisfiable sets, so that given an interpretation I the c-atom can be handled simply by introducing a special atom θA together with a new clause θA ← A1,..., An for each satisfiable set {A1,..., An} of A. We also prove that the latest fixpoint approach presented by Son et al. and our approach using the generalized Gelfond-Lifschitz transformation are semantically equivalent in the sense that they define the same set of stable models.
Partitioning ABoxes Based on Converting DL to Plain Datalog.

Logic Programs with Abstract Constraints Representaton

Linear Tabling Strategies and Optimizations

Clustering Using an Improved Hybrid Genetic Algorithm.

Deriving a Stationary Dynamic Bayesian Network from a Logic Program with Recursive Loops.

Deriving a Stationary Dynamic Bayesian Network from a Logic Program with Recursive Loops

Enhancing Global SLS%2DResolution with Loop Cutting and Tabling Mechanisms
Global SLS-resolution is a well-known procedural semantics for top-down computation of queries under the well-founded model. It inherits from SLDNF-resolution the linearity property of derivations, which makes it easy and efficient to implement using a simple stack-based memory structure. However, like SLDNF-resolution it suffers from the problem of infinite loops and redundant computations. To resolve this problem, in this paper we develop a new procedural semantics, called SLTNF-resolution, by enhancing Global SLS-resolution with loop cutting and tabling mechanisms. SLTNFresolution is sound and complete w.r.t. the well-founded semantics for logic programs with the bounded-term-size property, and is superior to existing linear tabling procedural semantics such as SLT-resolution. Keywords: Logic programming, the well-founded semantics, Global SLS-resolution, loop cutting, tabling.
Enhancing Global SLS%2DResolution with Loop Cutting and Tabling Mechanisms
Global SLS-resolution is a well-known procedural semantics for top-down computation of queries under the well-founded model. It inherits from SLDNF-resolution the linearity property of derivations, which makes it easy and efficient to implement using a simple stack-based memory structure. However, like SLDNF-resolution it suffers from the problem of infinite loops and redundant computations. To resolve this problem, in this paper we develop a new procedural semantics, called SLTNF-resolution, by enhancing Global SLS-resolution with loop cutting and tabling mechanisms. SLTNFresolution is sound and complete w.r.t. the well-founded semantics for logic programs with the bounded-term-size property, and is superior to existing linear tabling procedural semantics such as SLT-resolution. Keywords: Logic programming, the well-founded semantics, Global SLS-resolution, loop cutting, tabling.
Termination Analysis of General Logic Programs for Moded Queries A Dynamic Approach

Cluster Cores%2DBased Clustering for High Dimensional Data.
We propose a new approach to clustering high dimensional data based on a novel notion of cluster cores, instead of on nearest neighbors. A cluster core is a fairly dense group with a maximal number of pairwise similar objects. It represents the core of a cluster, as all objects in a cluster are with a great degree attracted to it. As a result, building clusters from cluster cores achieves high accuracy. Other major characteristics of the approach include: (1) It uses a semantics-based similarity measure. (2) It does not incur the curse of dimensionality and is scalable linearly with the dimensionality of data. (3) It outperforms the wellknown clustering algorithm, ROCK, with both lower time complexity and higher accuracy. 1
Semi%2Dnaive evaluation in linear tabling.

Clustering High%2DDimensional Data with Low%2DOrder Neighbors.

Mining High Utility Itemsets.
Mining High Utility Itemsets from a transaction database is to find itemsests that have utility above a user-specified threshold. This problem is an extension of Frequent Itemset Mining, which discovers itemsets that occur frequently (i.e. with occurrence count larger than a user given value). The problem of finding High Utility Itemsets is challenging, because the anti-monotone property so useful for pruning the search space in conventional Frequent Itemset Mining does not apply to it. In this paper we propose a new algorithm called CTU-PRO that mines high utility itemsets by bottom up traversal of a compressed utility pattern (CUP) tree. We have tested our algorithm on several sparse and dense data sets, comparing it with the recent algorithms for High Utility Itemset Mining and the results show that our algorithm 1 works more efficiently.
Mining the Customer%27s Up%2DTo%2DMoment Preferences for E%2Dcommerce Recommendation.
Most existing data mining approaches to e-commerce recommendation  are past data model-based in the sense that they  rst build  a preference model from a past dataset and then apply the model to  current customer situations. Such approaches are not suitable for applications  where fresh data should be collected instantly since it reects  changes to customer preferences over some products. This paper targets  those e-commerce environments in which knowledge of customer preferences  may change frequently. But due to the very large size of past  datasets the preference models cannot be updated instantly in response  to the changes. We present an approach to making real time online recommendations  based on an up-to-moment dataset which includes not  only a gigantic past dataset but the most recent data that may be collected  just moments ago.
A dynamic approach to characterizing termination of general logic programs.
this paper we do not consider oundering a situation where a non-ground negative subgoal is selected by R (see the case 2c). See [Chan 1988] for discussion on such topic
Objective%2DOriented Utility%2DBased Association Mining.
The necessity to develop methods for discovering association patterns to increase business utility of an enterprise has long been recognized in data mining community. This requires modeling specific association patterns that are both statistically (based on support and confidence) and semantically (based on objective utility) relating to a given objective that a user wants to achieve or is interested in. However, we notice that no such a general model has been reported in the literature. Traditional association mining focuses on deriving correlations among a set of items and their association rules like ¢¤£¦¥¨§�©¨������©�©� � only tell us that a pattern like ��¢¤£¦¥¨§�©¨�� � is statistically related to an item like ��©�©� �. In this paper, we present a new approach, called Objective-Oriented utility-based Association (OOA) mining, to modeling such association patterns that are explicitly relating to a user’s objective and its utility. Due to its focus on a user’s objective and the use of objective utility as key semantic information to measure the usefulness of association patterns, OOA mining differs significantly from existing approaches such as the existing constraint-based association mining. We formally define OOA mining and develop an algorithm for mining OOA rules. The algorithm is an enhancement to Apriori with specific mechanisms for handling objective utility. We prove that the utility constraint is neither monotone nor anti-monotone nor succinct nor convertible and present a novel pruning strategy based on the utility constraint to improve the efficiency of OOA mining. 1
A Dynamic Approach to Characterizing Termination of General Logic Programs
this paper we do not consider oundering a situation where a non-ground negative subgoal is selected by R (see the case 2c). See [Chan 1988] for discussion on such topic
SLT%2DResolution for the Well%2DFounded Semantics.
Global SLS-resolution and SLG-resolution are two representative mechanisms for  top-down evaluation of the well-founded semantics of general logic programs. Global  SLS-resolution is linear for query evaluation but suffers from infinite loops and redundant  computations. In contrast, SLG-resolution resolves infinite loops and redundant  computations by means of tabling, but it is not linear. The principal disadvantage  of a non-linear approach is that it cannot be implemented using a simple, efficient  stack-based memory structure nor can it be easily extended to handle some strictly  sequential operators such as cuts in Prolog.
Implementation of a Linear Tabling Mechanism.
Delaying-based tabling mechanisms, such as the one adopted in XSB, are non-linear in the sense that the computation state of delayed calls has to be preserved. In this paper, we present the implementation of a linear tabling mechanism. The key idea is to let a call execute from the backtracking point of a former variant call if such a call exists. The linear tabling mechanism has the following advantages over non-linear ones: (1) it is relatively easy to implement; (2) it imposes no overhead on standard Prolog programs; and (3) the cut operator works as for standard Prolog programs and thus it is possible to use the cut operator to express negation-as-failure and conditionals in tabled programs. The weakness of the linear mechanism is the necessity of re-computation for computing x-points. However, we have found that re-computation can be avoided for a large portion of calls of directly-recursive tabled predicates. We have implemented the linear tabling mechanism in B-P...
Linear tabulated resolution based on Prolog control strategy.
In nite loops and redundant computations are long recognized open problems in Prolog. Two ways have been explored to resolve these problems: loop checking and tabling. Loop checking can cut innite loops, but it cannot be both sound and complete even for function-free logic programs. Tabling seems to be an eective way to resolve in-nite loops and redundant computations. However, existing tabulated resolutions, such as OLDT-resolution, SLG-resolution, and Tabulated SLS-resolution, are non-linear because they rely on the solution-lookup mode in formulating tabling. The principal disadvantage of non-linear resolutions is that they cannot be implemented using a simple stack-based memory structure like that in Prolog. Moreover, some strictly sequential operators such as cuts may not be handled as easily as in Prolog. In this paper, we propose a hybrid method to resolve innite loops and redundant computations. We combine the ideas of loop checking and tabling to establish a linear tabulated resolution called TP-resolution. TP-resolution has two distinctive features: (1) It makes linear tabulated derivations in the same way as Prolog except that innite loops are broken and redundant computations are reduced. It handles cuts as eectively as Prolog. (2) It is sound and complete for positive logic programs with the bounded-term-size property. The underlying algorithm can be implemented by an extension to any existing Prolog abstract machines such as WAM or ATOAM.
Loop checks for logic programs with functions.
Two complete loop checking mechanisms have been presented in the literature for logic  programs with functions: OS-check and EVA-check. OS-check is computationally ecient but  quite unreliable in that it often mis-identies innite loops, whereas EVA-check is reliable for  a majority of cases but quite expensive. In this paper, we develop a series of new complete  loop checking mechanisms, called VAF-checks. The key technique we introduce is the notion of  expanded variants, which captures a key structural characteristic of innite loops. We show that  our approach is superior to both OS-check and EVA-check in that it is as ecient as OS-check  and as reliable as EVA-check.  Keywords: Loop checking, logic programming.  1 
Implementation of a Linear Tabling Mechanism.
Delaying-based tabling mechanisms, such as the one adopted in XSB, are non-linear in the sense that the computation state of delayed calls has to be preserved. In this paper, we present the implementation of a linear tabling mechanism. The key idea is to let a call execute from the backtracking point of a former variant call if such a call exists. The linear tabling mechanism has the following advantages over non-linear ones: (1) it is relatively easy to implement; (2) it imposes no overhead on standard Prolog programs; and (3) the cut operator works as for standard Prolog programs and thus it is possible to use the cut operator to express negation-as-failure and conditionals in tabled programs. The weakness of the linear mechanism is the necessity of re-computation for computing x-points. However, we have found that re-computation can be avoided for a large portion of calls of directly-recursive tabled predicates. We have implemented the linear tabling mechanism in B-P...
SLT%2DResolution for the Well%2DFounded Semantics
Global SLS-resolution and SLG-resolution are two representative mechanisms for  top-down evaluation of the well-founded semantics of general logic programs. Global  SLS-resolution is linear for query evaluation but suffers from infinite loops and redundant  computations. In contrast, SLG-resolution resolves infinite loops and redundant  computations by means of tabling, but it is not linear. The principal disadvantage  of a non-linear approach is that it cannot be implemented using a simple, efficient  stack-based memory structure nor can it be easily extended to handle some strictly  sequential operators such as cuts in Prolog.
Linear Tabulated Resolution Based on Prolog Control Strategy
In nite loops and redundant computations are long recognized open problems in Prolog. Two ways have been explored to resolve these problems: loop checking and tabling. Loop checking can cut innite loops, but it cannot be both sound and complete even for function-free logic programs. Tabling seems to be an eective way to resolve in-nite loops and redundant computations. However, existing tabulated resolutions, such as OLDT-resolution, SLG-resolution, and Tabulated SLS-resolution, are non-linear because they rely on the solution-lookup mode in formulating tabling. The principal disadvantage of non-linear resolutions is that they cannot be implemented using a simple stack-based memory structure like that in Prolog. Moreover, some strictly sequential operators such as cuts may not be handled as easily as in Prolog. In this paper, we propose a hybrid method to resolve innite loops and redundant computations. We combine the ideas of loop checking and tabling to establish a linear tabulated resolution called TP-resolution. TP-resolution has two distinctive features: (1) It makes linear tabulated derivations in the same way as Prolog except that innite loops are broken and redundant computations are reduced. It handles cuts as eectively as Prolog. (2) It is sound and complete for positive logic programs with the bounded-term-size property. The underlying algorithm can be implemented by an extension to any existing Prolog abstract machines such as WAM or ATOAM.
Verifying Termination of General Logic Programs with Concrete Queries

A Linear Tabling Mechanism.
Delaying-based tabling mechanisms, such as the one adopted in XSB, are non-linear in the sense that the computation state of delayed calls has to be preserved. In this paper, we present the implementation of a linear tabling mechanism. The key idea is to let a call execute from the backtracking point of a former variant call if such a call exists. The linear tabling mechanism has the following advantages over non-linear ones: (1) it is relatively easy to implement; (2) it imposes no overhead on standard Prolog programs; and (3) the cut operator works as for standard Prolog programs and thus it is possible to use the cut operator to express negation-as-failure and conditionals in tabled programs. The weakness of the linear mechanism is the necessity of re-computation for computing x-points. However, we have found that re-computation can be avoided for a large portion of calls of directly-recursive tabled predicates. We have implemented the linear tabling mechanism in B-P...
Linear Tabulated Resolutions for the Well%2DFounded Semantics.
Abstract. Global SLS-resolution and SLG-resolution are two representative mechanisms for top-down evaluation of the well-founded semantics of general logic programs. Global SLS-resolution is linear but suffers from infinite loops and redundant computations. In contrast, SLG-resolution resolves infinite loops and redundant computations by means of tabling, but it is not linear. The distinctive advantage of a linear approach is that it can be implemented using a simple, efficient stack-based memory structure like that in Prolog. In this paper we present a linear tabulated resolution for the well-founded semantics, which resolves the problems of infinite loops and redundant computations while preserving the linearity. For non-floundering queries, the proposed method is sound and complete for general logic programs with the bounded-term-size property. 1
An Extended Variant of Atoms Loop Check for Positive Logic Programs.
The Equality check and the Subsumption check are weakly sound, but are not complete even for function-free logic programs. Although the OverSize (OS) check is complete for positive logic programs, it is too general in the sense that it prunes SLD-derivations merely based on the depth-bound of repeated predicate symbols and the size of atoms, regardless of the inner structure of the atoms, so it may make wrong conclusions even for some simple programs. In this paper, we explore complete loop checking mechanisms for positive logic programs. We develop an extended Variant of Atoms (VA) check that has the following features: (1) it generalizes the concept of \variant&#034; from \the same up to variable renaming&#034; to \ the same up to variable renaming except possibly with some arguments whose size recursively increases,&#034; (2) it makes use of the depth-bound of repeated variants of atoms instead of the depth-bound of repeated predicate symbols, (3) it combines the Equality/Subsumption check with th...
Verifying Local Stratifiability of Logic Programs and Databases II.

Verifying Local Stratifiability of Logic Programs and Databases.

